The invention relates to an apparatus and a method for generating OVSF code words for CDMA methods, particularly in the field of mobile radio technology.
The CDMA method (CDMA: Code Division Multiple Access) is a channel access method, particularly for cellular systems for the mobile radio sector. In this case, a narrowband signal is spread using a code to form a broadband signal. This is done by virtue of a digital data stream which is to be transmitted not being transmitted directly as a succession of the bit values 0 and 1, but rather by virtue of the digital user data values 0 and 1 being represented by a succession of n likewise binary symbols, so-called code chips. CDMA is more immune to interference than TDMA (Time Division Multiple Access) or FDMA (Frequency Division Multiple Access), since it is less susceptible to fading. Furthermore, CDMA makes optimum use of the available frequency spectrum by dispensing with guard bands and guard time. The CDMA method is clearly a method in which a plurality of call parties speak in one space, with two call parties respectively conversing in their own language. This is achieved by using orthogonal codes having a variable spreading factor, so-called OVSF codes. The OVSF codes ensure orthogonality between different transmissions in a physical transmission channel. The OVSF codes make it possible to transmit data simultaneously over a plurality of data channels at different data transmission rates by using different codes having different spreading factors. The spreading factor is the number of code chips per data symbol. The product of the data rate and the spreading factor is constant and corresponds to the chip rate of the system, for example 3.84 MHz for UMTS.
OVSF codes are periodic codes whose period is equal to the duration of the symbol. OVSF codes have been generated to date using the recursive relationship below.
C1,1=0                               [                                                                      C                                      2                    ,                    1                                                                                                                        c                                      2                    ,                    2                                                                                ]                =                              [                                                                                                      C                                              1                        ,                        1                                                                                                                                                        C                                              1                        ,                        k1                                                                                                        ⁢                                                                                                                  C                                                  1                          ,                          1                                                                    _                                                                                                                                  C                                              1                        ,                        1                                                                                                                  ]                    =                      [                                                                                0                                                                                        0                                                              ⁢                                                                    0                                                                                        1                                                                        ]                                                            [                                                                      C                                      4                    ,                    1                                                                                                                        C                                      4                    ,                    2                                                                                                                        C                                      4                    ,                    3                                                                                                                        C                                      4                    ,                    4                                                                                ]                =                              [                                                                                                      C                                              2                        ,                        1                                                                                                                                                        C                                              2                        ,                        1                                                                                                                                                        C                                              2                        ,                        2                                                                                                                                                        C                                              2                        ,                        2                                                                                                        ⁢                                                                                                                                                                                                      C                                                              2                                ,                                1                                                                                      _                                                                                                                                                                            C                                                          2                              ,                              1                                                                                                                                                                                                                                                                                                                                                  C                                                              2                                ,                                2                                                                                      _                                                                                                                                                                            C                                                          2                              ,                              2                                                                                                                                                                                                ]                    =                      [                                                                                0                                                                                        0                                                                                        0                                                                                        0                                                              ⁢                                                                                                                                            0                                                                                                                      0                                                                                                                                                                                                                                  1                                                                                                                      1                                                                                                                                ⁢                                                                                                                                            0                                                                                                                      1                                                                                                                                                                                                                                  0                                                                                                                      1                                                                                                                                ⁢                                                                                                                                            0                                                                                                                      1                                                                                                                                                                                                                                  1                                                                                                                      0                                                                                                                                          ]                                                            [                                                                      C                                      2                                                                  n                        +                        1                                            ,                      1                                                                                                                                            C                                      2                                                                  n                        +                        1                                            ,                      2                                                                                                                                            C                                      2                                                                  n                        +                        1                                            ,                      3                                                                                                                                            C                                      2                                                                  n                        +                        1                                            ,                      4                                                                                                                          ⋮                                                                                      C                                                            2                                              n                        +                        1                                                              ,                                                                  2                                                  n                          +                          1                                                                    -                      1                                                                                                                                            C                                                            2                                              n                        +                        1                                                              ⁢                                          2                                              n                        +                        1                                                                                                                          ]                =                  [                                                                                          C                                                                  2                        n                                            ·                      1                                                                                                                                        C                                                                  2                        n                                            ·                      1                                                                                                                                        C                                                                  2                        n                                            ·                      2                                                                                                                                        C                                                                  2                        n                                            ·                      2                                                                                                                    ⋮                                                                                                  C                                                                  2                        n                                            ·                                              2                        n                                                                                                                                                              C                                                                  2                        n                                            ·                                              2                        n                                                                                                                  ⁢                                                                                                                                                                                                                                                                                                                                                                                                      C                                                                                                                              2                                            n                                                                                    ·                                          1                                                                                                                    _                                                                                                                                                                                                                                                  C                                                                                                                        2                                          n                                                                                ·                                        1                                                                                                                                                                                                                                                                                                                                                                                      C                                                                                                            2                                      n                                                                        ·                                    2                                                                                                  _                                                                                                                                                                                                                                                  C                                                                                    2                              n                                                        ·                            2                                                                                                                                                                                                                                                              ⋮                                                                                                                                                                                                                                                                  C                                                                                                            2                                      n                                                                        ·                                                                          2                                      n                                                                                                                                      _                                                                                                                                                                                                        C                                                                                                      2                                    n                                                                    ·                                                                      2                                    n                                                                                                                                                                                                                                                                                                        ]                    
OVSF codes are shown most clearly in a code tree structure.
FIG. 1 shows an example of an OVSF code tree whose spreading factor ranges from 1 to 8. The code allocation rule for OVSF codes, which ensures the orthogonality between the physical data transmission channels, is that, if a branch of the code tree is used for coding, all the preceding and succeeding branches in the tree structure are not permitted for further coding. If, by way of example, the code C4,1 in the OVSF code tree shown in FIG. 1 is allocated for coding a channel, then the codes C2,1, C1,1, C8,1 and C8,2 are blocked until the allocated code C4,1 has been released again.
The previously known methods for generating OVSF codes generate the OVSF code word using the above recursive description. This recursive calculation convention requires a high level of computational complexity and a large number of computational operations, however. Such OVSF code word generators based on the prior art are therefore very complex in terms of circuitry and require a large amount of storage space.
It is therefore the object of the present invention to provide an apparatus and a method for generating OVSF code words in which the OVSF code word is generated with very little complexity in terms of circuitry.
The invention achieves this object by means of a method having [lacuna] features specified in patent claim 1 and by means of an apparatus having the features specified in patent claim 6.
The invention provides a method for generating an OVSF code word from code tree index data associated with a particular OVSF code within a prescribed OVSF tree, where a first code tree index data item (i) indicates the spreading factor of the OVSF code, and a second code tree index data item (j) indicates the position of the OVSF code among OVSF codes having the same spreading factor within the OVSF code tree, the method having the following steps:
a calculation index is calculated on the basis of the second code tree index data item (j),
the calculated calculation index is buffered as a binary data word having a plurality of data bits, the word length of the binary data word is calculated; the data bits of the data word are interchanged bit by bit in order to form a calculation base,
the calculation base is logically combined with a counting variable in order to form a logically combined data word, and
the logically combined data word is logically reduced in order to generate the OVSF code word.
The calculation index is preferably calculated by subtracting 1 from the second code tree index data item (j).
In one preferred development, the calculation base is logically ANDed with the counting variable bit by bit.
In one preferred development, the logically combined data word is logically reduced by means of multistage XORing of adjacent data bits.
In one preferred embodiment of the inventive method, the counting variable is generated by a modulo counter whose modulo base corresponds to the spreading factor of the OVSF code word which is to be generated.
The invention also provides a code word generator for OVSF codes, having
a buffer device for writing in a calculation index as a binary calculation index data word,
a calculation device which interchanges the data bits of the calculation index data word bit by bit in order to generate a calculation base,
a counter for generating a counting variable, and having
a logic circuit which has a plurality of AND gates for logically ANDing the generated counting variable with the calculation base bit by bit to form a logically combined data word, and a plurality of XOR gates for logically reducing the logically combined data word formed in order to form code word chips of the OVSF code word.
The code word generator preferably has an input buffer for reading in a first code tree index data item index data item [sic] (i) and a second code tree index data item (j), the first code tree index data item (i) indicating the spreading factor of the OVSF code, and the second code tree index data item (j) indicating the position of the OVSF code among the OVSF codes having the same spreading factor within the OVSF code tree.
Preferably, a subtraction device is provided which reduces the second code tree index data item (j) by 1 in order to calculate the calculation index.
In one preferred development, the counter is a modulo counter whose modulo counting base is adjustable.
In one preferred development, the modulo counting base corresponds to the spreading factor of the OVSF code word which is to be generated.
In another preferred development, a calculation unit is provided which is used for calculating the data word length of the calculation index data word.
In another preferred development, the calculated data word length of the calculation index data word is stored in a buffer.
In another preferred embodiment of the inventive code word generator, an output buffer is provided which buffers the code word data bits generated by the logic circuit in order to form the OVSF code word.
The counter is preferably clocked at the code chip frequency.
The text below describes preferred embodiments of the inventive method and of the inventive code word generator for OVSF codes in accordance with the invention with reference to the appended figures to illustrate inventive features.